Update gir version

diff --git a/rust-bindings/rust/Makefile b/rust-bindings/rust/Makefile
index 1e598acf91a3c017fcd9c8526448f0a2e84f66da..5f1b3231a4b462d1cfe1b1b30745a4dd5abeb67b 100644 (file)
--- a/rust-bindings/rust/Makefile
+++ b/rust-bindings/rust/Makefile
@@ -5,7 +5,7 @@ all: gir
 
 # -- gir generation --
 target/tools/bin/gir:
-       cargo install --root target/tools --git https://github.com/gtk-rs/gir.git --rev 20feecf4fe8b4f3524715a0d4111f8c279666324 -- gir
+       cargo install --root target/tools --git https://github.com/gtk-rs/gir.git --rev c0f523f42d1c54e3489ae33e5464ecaaf0db3fd4 -- gir
 
 gir: target/tools/bin/gir
        target/tools/bin/gir -c conf/ostree-sys.toml

diff --git a/rust-bindings/rust/src/auto/collection_ref.rs b/rust-bindings/rust/src/auto/collection_ref.rs
index b3c4c438f21addf17ac44c97baf38da9e2ef02f3..47c092eb8e584c717042feacd71a43f68f3cc185 100644 (file)
--- a/rust-bindings/rust/src/auto/collection_ref.rs
+++ b/rust-bindings/rust/src/auto/collection_ref.rs
@@ -4,6 +4,7 @@
 
 #[cfg(any(feature = "v2018_6", feature = "dox"))]
 use glib::translate::*;
+#[cfg(any(feature = "v2018_6", feature = "dox"))]
 use glib_sys;
 use gobject_sys;
 use ostree_sys;

diff --git a/rust-bindings/rust/src/auto/functions.rs b/rust-bindings/rust/src/auto/functions.rs
index c59f5ede2035c68d1b7ce382e50301d29f82325a..639310988a63202e322aad0d682ecb1c8f6a7a6a 100644 (file)
--- a/rust-bindings/rust/src/auto/functions.rs
+++ b/rust-bindings/rust/src/auto/functions.rs
@@ -192,8 +192,9 @@ pub fn metadata_variant_type(objtype: ObjectType) -> Option<glib::VariantType> {
 pub fn object_from_string(str: &str) -> (GString, ObjectType) {
     unsafe {
         let mut out_checksum = ptr::null_mut();
-        let mut out_objtype = mem::uninitialized();
-        ostree_sys::ostree_object_from_string(str.to_glib_none().0, &mut out_checksum, &mut out_objtype);
+        let mut out_objtype = mem::MaybeUninit::uninit();
+        ostree_sys::ostree_object_from_string(str.to_glib_none().0, &mut out_checksum, out_objtype.as_mut_ptr());
+        let out_objtype = out_objtype.assume_init();
         (from_glib_full(out_checksum), from_glib(out_objtype))
     }
 }
@@ -201,8 +202,9 @@ pub fn object_from_string(str: &str) -> (GString, ObjectType) {
 pub fn object_name_deserialize(variant: &glib::Variant) -> (GString, ObjectType) {
     unsafe {
         let mut out_checksum = ptr::null();
-        let mut out_objtype = mem::uninitialized();
-        ostree_sys::ostree_object_name_deserialize(variant.to_glib_none().0, &mut out_checksum, &mut out_objtype);
+        let mut out_objtype = mem::MaybeUninit::uninit();
+        ostree_sys::ostree_object_name_deserialize(variant.to_glib_none().0, &mut out_checksum, out_objtype.as_mut_ptr());
+        let out_objtype = out_objtype.assume_init();
         (from_glib_none(out_checksum), from_glib(out_objtype))
     }
 }
@@ -264,9 +266,10 @@ pub fn raw_file_to_archive_z2_stream_with_options<P: IsA<gio::InputStream>, Q: I
 pub fn raw_file_to_content_stream<P: IsA<gio::InputStream>, Q: IsA<gio::Cancellable>>(input: &P, file_info: &gio::FileInfo, xattrs: Option<&glib::Variant>, cancellable: Option<&Q>) -> Result<(gio::InputStream, u64), Error> {
     unsafe {
         let mut out_input = ptr::null_mut();
-        let mut out_length = mem::uninitialized();
+        let mut out_length = mem::MaybeUninit::uninit();
         let mut error = ptr::null_mut();
-        let _ = ostree_sys::ostree_raw_file_to_content_stream(input.as_ref().to_glib_none().0, file_info.to_glib_none().0, xattrs.to_glib_none().0, &mut out_input, &mut out_length, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+        let _ = ostree_sys::ostree_raw_file_to_content_stream(input.as_ref().to_glib_none().0, file_info.to_glib_none().0, xattrs.to_glib_none().0, &mut out_input, out_length.as_mut_ptr(), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+        let out_length = out_length.assume_init();
         if error.is_null() { Ok((from_glib_full(out_input), out_length)) } else { Err(from_glib_full(error)) }
     }
 }

diff --git a/rust-bindings/rust/src/auto/gpg_verify_result.rs b/rust-bindings/rust/src/auto/gpg_verify_result.rs
index 515f74dc3708e94bf50e2d3bfbe007872c86e519..7a7e264cfd5dd26b757defeeb8aa8a90e2390234 100644 (file)
--- a/rust-bindings/rust/src/auto/gpg_verify_result.rs
+++ b/rust-bindings/rust/src/auto/gpg_verify_result.rs
@@ -52,8 +52,9 @@ impl GpgVerifyResult {
 
     pub fn lookup(&self, key_id: &str) -> Option<u32> {
         unsafe {
-            let mut out_signature_index = mem::uninitialized();
-            let ret = from_glib(ostree_sys::ostree_gpg_verify_result_lookup(self.to_glib_none().0, key_id.to_glib_none().0, &mut out_signature_index));
+            let mut out_signature_index = mem::MaybeUninit::uninit();
+            let ret = from_glib(ostree_sys::ostree_gpg_verify_result_lookup(self.to_glib_none().0, key_id.to_glib_none().0, out_signature_index.as_mut_ptr()));
+            let out_signature_index = out_signature_index.assume_init();
             if ret { Some(out_signature_index) } else { None }
         }
     }

diff --git a/rust-bindings/rust/src/auto/repo.rs b/rust-bindings/rust/src/auto/repo.rs
index 4efab7cbe3c19f6ebe9461e4efbe59114993bd85..9d96a25ce3be7940851d3a235d7e739f7089f9ff 100644 (file)
--- a/rust-bindings/rust/src/auto/repo.rs
+++ b/rust-bindings/rust/src/auto/repo.rs
@@ -43,6 +43,7 @@ use glib_sys;
 use gobject_sys;
 use libc;
 use ostree_sys;
+#[cfg(any(feature = "v2016_8", feature = "dox"))]
 use std;
 use std::boxed::Box as Box_;
 use std::fmt;
@@ -220,9 +221,10 @@ impl Repo {
     #[cfg(any(feature = "v2018_9", feature = "dox"))]
     pub fn get_min_free_space_bytes(&self) -> Result<u64, Error> {
         unsafe {
-            let mut out_reserved_bytes = mem::uninitialized();
+            let mut out_reserved_bytes = mem::MaybeUninit::uninit();
             let mut error = ptr::null_mut();
-            let _ = ostree_sys::ostree_repo_get_min_free_space_bytes(self.to_glib_none().0, &mut out_reserved_bytes, &mut error);
+            let _ = ostree_sys::ostree_repo_get_min_free_space_bytes(self.to_glib_none().0, out_reserved_bytes.as_mut_ptr(), &mut error);
+            let out_reserved_bytes = out_reserved_bytes.assume_init();
             if error.is_null() { Ok(out_reserved_bytes) } else { Err(from_glib_full(error)) }
         }
     }
@@ -248,9 +250,10 @@ impl Repo {
     #[cfg(any(feature = "v2016_5", feature = "dox"))]
     pub fn get_remote_boolean_option(&self, remote_name: &str, option_name: &str, default_value: bool) -> Result<bool, Error> {
         unsafe {
-            let mut out_value = mem::uninitialized();
+            let mut out_value = mem::MaybeUninit::uninit();
             let mut error = ptr::null_mut();
-            let _ = ostree_sys::ostree_repo_get_remote_boolean_option(self.to_glib_none().0, remote_name.to_glib_none().0, option_name.to_glib_none().0, default_value.to_glib(), &mut out_value, &mut error);
+            let _ = ostree_sys::ostree_repo_get_remote_boolean_option(self.to_glib_none().0, remote_name.to_glib_none().0, option_name.to_glib_none().0, default_value.to_glib(), out_value.as_mut_ptr(), &mut error);
+            let out_value = out_value.assume_init();
             if error.is_null() { Ok(from_glib(out_value)) } else { Err(from_glib_full(error)) }
         }
     }
@@ -286,9 +289,10 @@ impl Repo {
 
     pub fn has_object<P: IsA<gio::Cancellable>>(&self, objtype: ObjectType, checksum: &str, cancellable: Option<&P>) -> Result<bool, Error> {
         unsafe {
-            let mut out_have_object = mem::uninitialized();
+            let mut out_have_object = mem::MaybeUninit::uninit();
             let mut error = ptr::null_mut();
-            let _ = ostree_sys::ostree_repo_has_object(self.to_glib_none().0, objtype.to_glib(), checksum.to_glib_none().0, &mut out_have_object, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+            let _ = ostree_sys::ostree_repo_has_object(self.to_glib_none().0, objtype.to_glib(), checksum.to_glib_none().0, out_have_object.as_mut_ptr(), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+            let out_have_object = out_have_object.assume_init();
             if error.is_null() { Ok(from_glib(out_have_object)) } else { Err(from_glib_full(error)) }
         }
     }
@@ -365,9 +369,10 @@ impl Repo {
     pub fn load_commit(&self, checksum: &str) -> Result<(glib::Variant, RepoCommitState), Error> {
         unsafe {
             let mut out_commit = ptr::null_mut();
-            let mut out_state = mem::uninitialized();
+            let mut out_state = mem::MaybeUninit::uninit();
             let mut error = ptr::null_mut();
-            let _ = ostree_sys::ostree_repo_load_commit(self.to_glib_none().0, checksum.to_glib_none().0, &mut out_commit, &mut out_state, &mut error);
+            let _ = ostree_sys::ostree_repo_load_commit(self.to_glib_none().0, checksum.to_glib_none().0, &mut out_commit, out_state.as_mut_ptr(), &mut error);
+            let out_state = out_state.assume_init();
             if error.is_null() { Ok((from_glib_full(out_commit), from_glib(out_state))) } else { Err(from_glib_full(error)) }
         }
     }
@@ -386,9 +391,10 @@ impl Repo {
     pub fn load_object_stream<P: IsA<gio::Cancellable>>(&self, objtype: ObjectType, checksum: &str, cancellable: Option<&P>) -> Result<(gio::InputStream, u64), Error> {
         unsafe {
             let mut out_input = ptr::null_mut();
-            let mut out_size = mem::uninitialized();
+            let mut out_size = mem::MaybeUninit::uninit();
             let mut error = ptr::null_mut();
-            let _ = ostree_sys::ostree_repo_load_object_stream(self.to_glib_none().0, objtype.to_glib(), checksum.to_glib_none().0, &mut out_input, &mut out_size, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+            let _ = ostree_sys::ostree_repo_load_object_stream(self.to_glib_none().0, objtype.to_glib(), checksum.to_glib_none().0, &mut out_input, out_size.as_mut_ptr(), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+            let out_size = out_size.assume_init();
             if error.is_null() { Ok((from_glib_full(out_input), out_size)) } else { Err(from_glib_full(error)) }
         }
     }
@@ -430,20 +436,24 @@ impl Repo {
 
     pub fn prepare_transaction<P: IsA<gio::Cancellable>>(&self, cancellable: Option<&P>) -> Result<bool, Error> {
         unsafe {
-            let mut out_transaction_resume = mem::uninitialized();
+            let mut out_transaction_resume = mem::MaybeUninit::uninit();
             let mut error = ptr::null_mut();
-            let _ = ostree_sys::ostree_repo_prepare_transaction(self.to_glib_none().0, &mut out_transaction_resume, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+            let _ = ostree_sys::ostree_repo_prepare_transaction(self.to_glib_none().0, out_transaction_resume.as_mut_ptr(), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+            let out_transaction_resume = out_transaction_resume.assume_init();
             if error.is_null() { Ok(from_glib(out_transaction_resume)) } else { Err(from_glib_full(error)) }
         }
     }
 
     pub fn prune<P: IsA<gio::Cancellable>>(&self, flags: RepoPruneFlags, depth: i32, cancellable: Option<&P>) -> Result<(i32, i32, u64), Error> {
         unsafe {
-            let mut out_objects_total = mem::uninitialized();
-            let mut out_objects_pruned = mem::uninitialized();
-            let mut out_pruned_object_size_total = mem::uninitialized();
+            let mut out_objects_total = mem::MaybeUninit::uninit();
+            let mut out_objects_pruned = mem::MaybeUninit::uninit();
+            let mut out_pruned_object_size_total = mem::MaybeUninit::uninit();
             let mut error = ptr::null_mut();
-            let _ = ostree_sys::ostree_repo_prune(self.to_glib_none().0, flags.to_glib(), depth, &mut out_objects_total, &mut out_objects_pruned, &mut out_pruned_object_size_total, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+            let _ = ostree_sys::ostree_repo_prune(self.to_glib_none().0, flags.to_glib(), depth, out_objects_total.as_mut_ptr(), out_objects_pruned.as_mut_ptr(), out_pruned_object_size_total.as_mut_ptr(), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+            let out_objects_total = out_objects_total.assume_init();
+            let out_objects_pruned = out_objects_pruned.assume_init();
+            let out_pruned_object_size_total = out_pruned_object_size_total.assume_init();
             if error.is_null() { Ok((out_objects_total, out_objects_pruned, out_pruned_object_size_total)) } else { Err(from_glib_full(error)) }
         }
     }
@@ -487,9 +497,10 @@ impl Repo {
 
     pub fn query_object_storage_size<P: IsA<gio::Cancellable>>(&self, objtype: ObjectType, sha256: &str, cancellable: Option<&P>) -> Result<u64, Error> {
         unsafe {
-            let mut out_size = mem::uninitialized();
+            let mut out_size = mem::MaybeUninit::uninit();
             let mut error = ptr::null_mut();
-            let _ = ostree_sys::ostree_repo_query_object_storage_size(self.to_glib_none().0, objtype.to_glib(), sha256.to_glib_none().0, &mut out_size, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+            let _ = ostree_sys::ostree_repo_query_object_storage_size(self.to_glib_none().0, objtype.to_glib(), sha256.to_glib_none().0, out_size.as_mut_ptr(), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+            let out_size = out_size.assume_init();
             if error.is_null() { Ok(out_size) } else { Err(from_glib_full(error)) }
         }
     }
@@ -577,18 +588,20 @@ impl Repo {
 
     pub fn remote_get_gpg_verify(&self, name: &str) -> Result<bool, Error> {
         unsafe {
-            let mut out_gpg_verify = mem::uninitialized();
+            let mut out_gpg_verify = mem::MaybeUninit::uninit();
             let mut error = ptr::null_mut();
-            let _ = ostree_sys::ostree_repo_remote_get_gpg_verify(self.to_glib_none().0, name.to_glib_none().0, &mut out_gpg_verify, &mut error);
+            let _ = ostree_sys::ostree_repo_remote_get_gpg_verify(self.to_glib_none().0, name.to_glib_none().0, out_gpg_verify.as_mut_ptr(), &mut error);
+            let out_gpg_verify = out_gpg_verify.assume_init();
             if error.is_null() { Ok(from_glib(out_gpg_verify)) } else { Err(from_glib_full(error)) }
         }
     }
 
     pub fn remote_get_gpg_verify_summary(&self, name: &str) -> Result<bool, Error> {
         unsafe {
-            let mut out_gpg_verify_summary = mem::uninitialized();
+            let mut out_gpg_verify_summary = mem::MaybeUninit::uninit();
             let mut error = ptr::null_mut();
-            let _ = ostree_sys::ostree_repo_remote_get_gpg_verify_summary(self.to_glib_none().0, name.to_glib_none().0, &mut out_gpg_verify_summary, &mut error);
+            let _ = ostree_sys::ostree_repo_remote_get_gpg_verify_summary(self.to_glib_none().0, name.to_glib_none().0, out_gpg_verify_summary.as_mut_ptr(), &mut error);
+            let out_gpg_verify_summary = out_gpg_verify_summary.assume_init();
             if error.is_null() { Ok(from_glib(out_gpg_verify_summary)) } else { Err(from_glib_full(error)) }
         }
     }
@@ -604,17 +617,18 @@ impl Repo {
 
     pub fn remote_gpg_import<P: IsA<gio::InputStream>, Q: IsA<gio::Cancellable>>(&self, name: &str, source_stream: Option<&P>, key_ids: &[&str], cancellable: Option<&Q>) -> Result<u32, Error> {
         unsafe {
-            let mut out_imported = mem::uninitialized();
+            let mut out_imported = mem::MaybeUninit::uninit();
             let mut error = ptr::null_mut();
-            let _ = ostree_sys::ostree_repo_remote_gpg_import(self.to_glib_none().0, name.to_glib_none().0, source_stream.map(|p| p.as_ref()).to_glib_none().0, key_ids.to_glib_none().0, &mut out_imported, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+            let _ = ostree_sys::ostree_repo_remote_gpg_import(self.to_glib_none().0, name.to_glib_none().0, source_stream.map(|p| p.as_ref()).to_glib_none().0, key_ids.to_glib_none().0, out_imported.as_mut_ptr(), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+            let out_imported = out_imported.assume_init();
             if error.is_null() { Ok(out_imported) } else { Err(from_glib_full(error)) }
         }
     }
 
     pub fn remote_list(&self) -> Vec<GString> {
         unsafe {
-            let mut out_n_remotes = mem::uninitialized();
-            let ret = FromGlibContainer::from_glib_full_num(ostree_sys::ostree_repo_remote_list(self.to_glib_none().0, &mut out_n_remotes), out_n_remotes as usize);
+            let mut out_n_remotes = mem::MaybeUninit::uninit();
+            let ret = FromGlibContainer::from_glib_full_num(ostree_sys::ostree_repo_remote_list(self.to_glib_none().0, out_n_remotes.as_mut_ptr()), out_n_remotes.assume_init() as usize);
             ret
         }
     }
@@ -980,9 +994,10 @@ impl Repo {
 
     pub fn mode_from_string(mode: &str) -> Result<RepoMode, Error> {
         unsafe {
-            let mut out_mode = mem::uninitialized();
+            let mut out_mode = mem::MaybeUninit::uninit();
             let mut error = ptr::null_mut();
-            let _ = ostree_sys::ostree_repo_mode_from_string(mode.to_glib_none().0, &mut out_mode, &mut error);
+            let _ = ostree_sys::ostree_repo_mode_from_string(mode.to_glib_none().0, out_mode.as_mut_ptr(), &mut error);
+            let out_mode = out_mode.assume_init();
             if error.is_null() { Ok(from_glib(out_mode)) } else { Err(from_glib_full(error)) }
         }
     }

diff --git a/rust-bindings/rust/src/auto/repo_file.rs b/rust-bindings/rust/src/auto/repo_file.rs
index d7e7b81e5cf9a360ff5203ff979facd734517dea..cb0b4b0b1406c67240c4b1464ff92768202cbe08 100644 (file)
--- a/rust-bindings/rust/src/auto/repo_file.rs
+++ b/rust-bindings/rust/src/auto/repo_file.rs
@@ -88,9 +88,10 @@ impl<O: IsA<RepoFile>> RepoFileExt for O {
 
     fn tree_find_child(&self, name: &str) -> (i32, bool, glib::Variant) {
         unsafe {
-            let mut is_dir = mem::uninitialized();
+            let mut is_dir = mem::MaybeUninit::uninit();
             let mut out_container = ptr::null_mut();
-            let ret = ostree_sys::ostree_repo_file_tree_find_child(self.as_ref().to_glib_none().0, name.to_glib_none().0, &mut is_dir, &mut out_container);
+            let ret = ostree_sys::ostree_repo_file_tree_find_child(self.as_ref().to_glib_none().0, name.to_glib_none().0, is_dir.as_mut_ptr(), &mut out_container);
+            let is_dir = is_dir.assume_init();
             (ret, from_glib(is_dir), from_glib_full(out_container))
         }
     }

diff --git a/rust-bindings/rust/src/auto/sysroot.rs b/rust-bindings/rust/src/auto/sysroot.rs
index 0cb924cb9078085d85debdd3023b486d998965a8..0fa9ab4f90e7c5626233796dd6c021327ea62248 100644 (file)
--- a/rust-bindings/rust/src/auto/sysroot.rs
+++ b/rust-bindings/rust/src/auto/sysroot.rs
@@ -207,9 +207,10 @@ impl Sysroot {
     #[cfg(any(feature = "v2016_4", feature = "dox"))]
     pub fn load_if_changed<P: IsA<gio::Cancellable>>(&self, cancellable: Option<&P>) -> Result<bool, Error> {
         unsafe {
-            let mut out_changed = mem::uninitialized();
+            let mut out_changed = mem::MaybeUninit::uninit();
             let mut error = ptr::null_mut();
-            let _ = ostree_sys::ostree_sysroot_load_if_changed(self.to_glib_none().0, &mut out_changed, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+            let _ = ostree_sys::ostree_sysroot_load_if_changed(self.to_glib_none().0, out_changed.as_mut_ptr(), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+            let out_changed = out_changed.assume_init();
             if error.is_null() { Ok(from_glib(out_changed)) } else { Err(from_glib_full(error)) }
         }
     }
@@ -307,9 +308,10 @@ impl Sysroot {
 
     pub fn try_lock(&self) -> Result<bool, Error> {
         unsafe {
-            let mut out_acquired = mem::uninitialized();
+            let mut out_acquired = mem::MaybeUninit::uninit();
             let mut error = ptr::null_mut();
-            let _ = ostree_sys::ostree_sysroot_try_lock(self.to_glib_none().0, &mut out_acquired, &mut error);
+            let _ = ostree_sys::ostree_sysroot_try_lock(self.to_glib_none().0, out_acquired.as_mut_ptr(), &mut error);
+            let out_acquired = out_acquired.assume_init();
             if error.is_null() { Ok(from_glib(out_acquired)) } else { Err(from_glib_full(error)) }
         }
     }

diff --git a/rust-bindings/rust/src/auto/sysroot_upgrader.rs b/rust-bindings/rust/src/auto/sysroot_upgrader.rs
index 4b95e1e9a9a4baf830a93d02feaad54783dde9b8..c42845e5b09bc95ccb5d355f9af7764f562beb75 100644 (file)
--- a/rust-bindings/rust/src/auto/sysroot_upgrader.rs
+++ b/rust-bindings/rust/src/auto/sysroot_upgrader.rs
@@ -84,18 +84,20 @@ impl SysrootUpgrader {
 
     pub fn pull<P: IsA<AsyncProgress>, Q: IsA<gio::Cancellable>>(&self, flags: RepoPullFlags, upgrader_flags: SysrootUpgraderPullFlags, progress: Option<&P>, cancellable: Option<&Q>) -> Result<bool, Error> {
         unsafe {
-            let mut out_changed = mem::uninitialized();
+            let mut out_changed = mem::MaybeUninit::uninit();
             let mut error = ptr::null_mut();
-            let _ = ostree_sys::ostree_sysroot_upgrader_pull(self.to_glib_none().0, flags.to_glib(), upgrader_flags.to_glib(), progress.map(|p| p.as_ref()).to_glib_none().0, &mut out_changed, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+            let _ = ostree_sys::ostree_sysroot_upgrader_pull(self.to_glib_none().0, flags.to_glib(), upgrader_flags.to_glib(), progress.map(|p| p.as_ref()).to_glib_none().0, out_changed.as_mut_ptr(), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+            let out_changed = out_changed.assume_init();
             if error.is_null() { Ok(from_glib(out_changed)) } else { Err(from_glib_full(error)) }
         }
     }
 
     pub fn pull_one_dir<P: IsA<AsyncProgress>, Q: IsA<gio::Cancellable>>(&self, dir_to_pull: &str, flags: RepoPullFlags, upgrader_flags: SysrootUpgraderPullFlags, progress: Option<&P>, cancellable: Option<&Q>) -> Result<bool, Error> {
         unsafe {
-            let mut out_changed = mem::uninitialized();
+            let mut out_changed = mem::MaybeUninit::uninit();
             let mut error = ptr::null_mut();
-            let _ = ostree_sys::ostree_sysroot_upgrader_pull_one_dir(self.to_glib_none().0, dir_to_pull.to_glib_none().0, flags.to_glib(), upgrader_flags.to_glib(), progress.map(|p| p.as_ref()).to_glib_none().0, &mut out_changed, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+            let _ = ostree_sys::ostree_sysroot_upgrader_pull_one_dir(self.to_glib_none().0, dir_to_pull.to_glib_none().0, flags.to_glib(), upgrader_flags.to_glib(), progress.map(|p| p.as_ref()).to_glib_none().0, out_changed.as_mut_ptr(), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+            let out_changed = out_changed.assume_init();
             if error.is_null() { Ok(from_glib(out_changed)) } else { Err(from_glib_full(error)) }
         }
     }

diff --git a/rust-bindings/rust/src/auto/versions.txt b/rust-bindings/rust/src/auto/versions.txt
index 8fead170c550a06697a0f49d56f5d5877829de09..ec3d64bbce330668aba1775920c8fe880822866c 100644 (file)
--- a/rust-bindings/rust/src/auto/versions.txt
+++ b/rust-bindings/rust/src/auto/versions.txt
@@ -1,2 +1,2 @@
-Generated by gir (https://github.com/gtk-rs/gir @ 20feecf)
+Generated by gir (https://github.com/gtk-rs/gir @ c0f523f)
 from gir-files (https://github.com/gtk-rs/gir-files @ ???)

diff --git a/rust-bindings/rust/sys/Cargo.toml b/rust-bindings/rust/sys/Cargo.toml
index 466488c7db901c605e95ff649622454ba970b991..2e6ead68b0d33306d43540ed5b44ba4feec336b5 100644 (file)
--- a/rust-bindings/rust/sys/Cargo.toml
+++ b/rust-bindings/rust/sys/Cargo.toml
@@ -62,3 +62,6 @@ repository = "https://gitlab.com/fkrull/ostree-rs"
 version = "0.4.0"
 [package.metadata.docs.rs]
 features = ["dox"]
+
+["package.metadata.docs.rs"]
+features = ["dox", "v2019_2"]

diff --git a/rust-bindings/rust/sys/build.rs b/rust-bindings/rust/sys/build.rs
index f71c57441f21cd33bae2c6359917ef05b368a723..857f74f784c62b05dbb89335fd45d340d437bdca 100644 (file)
--- a/rust-bindings/rust/sys/build.rs
+++ b/rust-bindings/rust/sys/build.rs
@@ -2,14 +2,24 @@
 // from gir-files (https://github.com/gtk-rs/gir-files)
 // DO NOT EDIT
 
+#[cfg(not(feature = "dox"))]
 extern crate pkg_config;
 
+#[cfg(not(feature = "dox"))]
 use pkg_config::{Config, Error};
+#[cfg(not(feature = "dox"))]
 use std::env;
+#[cfg(not(feature = "dox"))]
 use std::io::prelude::*;
+#[cfg(not(feature = "dox"))]
 use std::io;
+#[cfg(not(feature = "dox"))]
 use std::process;
 
+#[cfg(feature = "dox")]
+fn main() {} // prevent linking libraries to avoid documentation failure
+
+#[cfg(not(feature = "dox"))]
 fn main() {
     if let Err(s) = find() {
         let _ = writeln!(io::stderr(), "{}", s);
@@ -17,6 +27,7 @@ fn main() {
     }
 }
 
+#[cfg(not(feature = "dox"))]
 fn find() -> Result<(), Error> {
     let package_name = "ostree-1";
     let shared_libs = ["ostree-1"];

diff --git a/rust-bindings/rust/sys/src/auto/versions.txt b/rust-bindings/rust/sys/src/auto/versions.txt
index 8fead170c550a06697a0f49d56f5d5877829de09..ec3d64bbce330668aba1775920c8fe880822866c 100644 (file)
--- a/rust-bindings/rust/sys/src/auto/versions.txt
+++ b/rust-bindings/rust/sys/src/auto/versions.txt
@@ -1,2 +1,2 @@
-Generated by gir (https://github.com/gtk-rs/gir @ 20feecf)
+Generated by gir (https://github.com/gtk-rs/gir @ c0f523f)
 from gir-files (https://github.com/gtk-rs/gir-files @ ???)